TY - JOUR A1 - Rein, Patrick A1 - Taeumel, Marcel A1 - Hirschfeld, Robert T1 - Making the domain tangible BT - implicit object lookup for source code readability JF - Design Thinking Research N2 - 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. KW - Source Code Readability KW - Domain Objects KW - StackOverflow KW - Squeak KW - Custom Writable Class Y1 - 2017 SN - 978-3-319-60967-6 SN - 978-3-319-60966-9 U6 - https://doi.org/10.1007/978-3-319-60967-6_9 SP - 171 EP - 194 PB - Springer CY - New York ER - TY - BOOK A1 - Berov, Leonid A1 - Henning, Johannes A1 - Mattis, Toni A1 - Rein, Patrick A1 - Schreiber, Robin A1 - Seckler, Eric A1 - Steinert, Bastian A1 - Hirschfeld, Robert T1 - Vereinfachung der Entwicklung von Geschäftsanwendungen durch Konsolidierung von Programmierkonzepten und -technologien N2 - Die Komplexität heutiger Geschäftsabläufe und die Menge der zu verwaltenden Daten stellen hohe Anforderungen an die Entwicklung und Wartung von Geschäftsanwendungen. Ihr Umfang entsteht unter anderem aus der Vielzahl von Modellentitäten und zugehörigen Nutzeroberflächen zur Bearbeitung und Analyse der Daten. Dieser Bericht präsentiert neuartige Konzepte und deren Umsetzung zur Vereinfachung der Entwicklung solcher umfangreichen Geschä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önnen transaktionale und analytische Anfragen in derselben objektorientierten Hochsprache implementiert werden, und dennoch nah an den Daten ausgeführt werden. Zweitens: Wir beschreiben Programmiersprachkonstrukte, welche es erlauben, Nutzeroberflächen sowie Nutzerinteraktionen generisch und unabhängig von konkreten Modellentitäten zu beschreiben. Um diese abstrakte Beschreibung nutzen zu können, reichert man die Domänenmodelle um vormals implizite Informationen an. Neue Modelle müssen nur um einige Informationen erweitert werden um bereits vorhandene Nutzeroberflächen und -interaktionen auch für sie verwenden zu können. Anpassungen, die nur für ein Modell gelten sollen, können unabhängig vom Standardverhalten, inkrementell, definiert werden. Drittens: Wir ermöglichen mit einem weiteren Programmiersprachkonstrukt die zusammenhängende Beschreibung von Abläufen der Anwendung, wie z.B. Bestellprozesse. Unser Programmierkonzept kapselt Nutzerinteraktionen in synchrone Funktionsaufrufe und macht somit Prozesse als zusammenhängende Folge von Berechnungen und Interaktionen darstellbar. Viertens: Wir demonstrieren ein Konzept, wie Endnutzer komplexe analytische Anfragen intuitiver formulieren kö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önnen. Hinsichtlich der Ausführungsdauer sind die generierten Anfragen äquivalent zu Anfragen, die mit konventionellen Anfragesprachen formuliert sind. Das Anfragemodell setzen wir in einem Prototypen um, der auf den zuvor eingeführten Konzepten aufsetzt. T3 - Technische Berichte des Hasso-Plattner-Instituts für Digital Engineering an der Universität Potsdam - 71 KW - Geschäftsanwendungen KW - Programmierkonzepte KW - Datenbank KW - Hauptspeicherdatenbank KW - Python KW - Spaltenlayout KW - Nebenläufigkeit KW - Transaktionen KW - Anfragesprache Y1 - 2013 U6 - http://nbn-resolving.de/urn/resolver.pl?urn:nbn:de:kobv:517-opus-64045 SN - 978-3-86956-231-5 PB - Universitätsverlag Potsdam CY - Potsdam ER - TY - JOUR A1 - Steinert, Bastian A1 - Cassou, Damien A1 - Hirschfeld, Robert T1 - CoExist overcoming aversion to change preserving immediate access to source code and run-time information of previous development states JF - ACM SIGPLAN notices N2 - 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. KW - Design KW - Experimentation KW - Human Factors KW - Continuous Testing KW - Continuous Versioning KW - Debugging KW - Evolution KW - Explore-first Programming KW - Fault Localization KW - Prototyping Y1 - 2013 U6 - https://doi.org/10.1145/2480360.2384591 SN - 0362-1340 VL - 48 IS - 2 SP - 107 EP - 117 PB - Association for Computing Machinery CY - New York ER - TY - JOUR A1 - Haupt, Michael A1 - Adams, Bram A1 - Timbermont, Stijn A1 - Gibbs, Celina A1 - Coady, Yvonne A1 - Hirschfeld, Robert T1 - Disentangling virtual machine architecture N2 - 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. Y1 - 2009 UR - http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=4124007 U6 - https://doi.org/10.1049/iet-sen.2007.0121 SN - 1751-8806 ER - TY - JOUR A1 - Steinert, Bastian A1 - Hirschfeld, Robert T1 - Applying design knowledge to programming Y1 - 2012 ER - TY - JOUR A1 - Hirschfeld, Robert A1 - Steinert, Bastian A1 - Lincke, Jens T1 - Agile software development in virtual collaboration environments Y1 - 2011 SN - 978-3-642-13756-3 ER - TY - JOUR A1 - Hirschfeld, Robert A1 - Perscheid, Michael A1 - Haupt, Michael T1 - Explicit use-case representation in object-oriented programming languages JF - ACM SIGPLAN notices N2 - 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. KW - design KW - languages KW - use-cases KW - separation of concerns KW - traceability Y1 - 2012 U6 - https://doi.org/10.1145/2168696.2047856 SN - 0362-1340 VL - 47 IS - 2 SP - 51 EP - 60 PB - Association for Computing Machinery CY - New York ER - TY - JOUR A1 - Lincke, Jens A1 - Appeltauer, Malte A1 - Steinert, Bastian A1 - Hirschfeld, Robert T1 - An open implementation for context-oriented layer composition in ContextJS JF - Science of computer programming N2 - 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. KW - ContextJS KW - Context-oriented programming KW - Open implementations KW - Dynamic adaptation KW - Scope Y1 - 2011 U6 - https://doi.org/10.1016/j.scico.2010.11.013 SN - 0167-6423 VL - 76 IS - 12 SP - 1194 EP - 1209 PB - Elsevier CY - Amsterdam ER - TY - JOUR A1 - Weiher, Marcel A1 - Hirschfeld, Robert T1 - Polymorphic identifiers: uniform resource access in objective-smalltalk JF - ACM SIGPLAN notices N2 - 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. KW - Identifiers KW - REST KW - Uniform Access Principle KW - Extensibility Y1 - 2014 U6 - https://doi.org/10.1145/2508168.2508169 SN - 0362-1340 SN - 1558-1160 VL - 49 IS - 2 SP - 61 EP - 71 PB - Association for Computing Machinery CY - New York ER - TY - JOUR A1 - Bauman, Spenser A1 - Bolz, Carl Friedrich A1 - Hirschfeld, Robert A1 - Kirilichev, Vasily A1 - Pape, Tobias A1 - Siek, Jeremy G. A1 - Tobin-Hochstadt, Sam T1 - Pycket: A Tracing JIT for a Functional Language JF - ACM SIGPLAN notices N2 - 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. KW - Experimentation KW - Languages KW - Measurement KW - Performance KW - JIT compilers KW - contracts KW - tracing KW - functional languages KW - Racket Y1 - 2015 U6 - https://doi.org/10.1145/2784731.2784740 SN - 0362-1340 SN - 1558-1160 VL - 50 IS - 9 SP - 22 EP - 34 PB - Association for Computing Machinery CY - New York ER -