DOCSLIB.ORG

A Pure Embedding of Roles Exploring 4-Dimensional Dispatch for Roles in Structured Contexts

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
A Pure Embedding of Roles Exploring 4-Dimensional Dispatch for Roles in Structured Contexts Faculty of Computer Science Institute of Software- and Multimedia-Technology Software Technology Group A PURE EMBEDDING OF ROLES EXPLORING 4-DIMENSIONAL DISPATCH FOR ROLES IN STRUCTURED CONTEXTS Max Leuthäuser Born on: 20th April 1989 in Dresden DISSERTATION to achieve the academic degree DOKTOR-INGENIEUR (DR.-ING.) Referee Prof. Anthony Sloane Supervising professors Prof. Uwe Aßmann Prof. Christel Baier Submitted on: 31st May 2017 Und es liegt darin der Wille, der nicht stirbt. Wer kennt die Geheimnisse des Willens und seine Gewalt? Denn Gott ist nichts als ein großer Wille, der mit der ihm eignen Kraft alle Dinge durchdringt. Der Mensch überliefert sich den Engeln oder dem Nichts einzig durch die Schwäche seines schlaffen Willens. Joseph Glanvill STATEMENT OF AUTHORSHIP I hereby certify that I have authored this Dissertation entitled A Pure Embedding of Roles independently and without undue assistance from third parties. No other than the resources and references indicated in this thesis have been used. I have marked both literal and accordingly adopted quotations as such. There were no additional persons involved in the intellectual preparation of the present thesis. I am aware that violations of this declaration may lead to subsequent withdrawal of the degree. Dresden, 31st May 2017 Max Leuthäuser ABSTRACT Present-day software systems have to fulfill an increasing number of requirements, which makes them more and more complex. Many systems need to anticipate changing contexts or need to adapt to changing business rules or requirements. The challenge of 21th- century software development will be to cope with these aspects. We believe that the role concept offers a simple way to adapt an object-oriented program to its changing context. In a role-based application, an object plays multiple roles during its lifetime. If the contexts are represented as first-class entities, they provide dynamic views to the object- oriented program, and if a context changes, the dynamic views can be switched easily, and the software system adapts automatically. However, the concepts of roles and dynamic contexts have been discussed for a long time in many areas of computer science. So far, their employment in an existing object-oriented language requires a specific runtime environment. Also, classical object-oriented languages and their runtime systems are not able to cope with essential role-specific features, such as true delegation or dynamic binding of roles. In addition to that, contexts and views seem to be important in software development. The traditional code-oriented approach to software engineering becomes less and less satisfactory. The support for multiple views of a software system scales much better to the needs of today’s systems. However, it relies on programming languages to provide roles for the construction of views. As a solution, this thesis presents an implementation pattern for role-playing objects that does not require a specific runtime system, the SCala ROles Language (SCROLL). Via this library approach, roles are embedded in a statically typed base language as dynamically evolving objects. The approach is pure in the sense that there is no need for an additional compiler or tooling. The implementation pattern is demonstrated on the basis of the Scala language. As technical support from Scala, the pattern requires dynamic mixins, compiler-translated function calls, and implicit conversions. The details how roles are implemented are hidden in a Scala library and therefore transparent to SCROLL programmers. The SCROLL library supports roles embedded in structured contexts. Additionally, a four-dimensional, context-aware dispatch at runtime is presented. It overcomes the subtle ambiguities introduced with the rich semantics of role-playing objects. SCROLL is written in Scala, which blends a modern object-oriented with a functional programming language. The size of the library is below 1400 lines of code so that it can be considered to have minimalistic design and to be easy to maintain. Our approach solves several practical problems arising in the area of dynamical extensibility and adaptation. ACKNOWLEDGMENTS We have talked so much about the reader, but you can- not forget that the opening line is important to the writer, too. To the person who is actually boots-on-the- ground. Because it is not just the readers way in, it is the writers way in also, and you have got to find a doorway that fits us both. Stephen King First, I would like to express my special thanks to my supervisor Uwe Aßmann. He supported me and the whole research group with a very special research atmosphere and gave me many useful and path-leading ideas, hints and comments. Additionally, I am very thankful for providing me the opportunity for my stay abroad at the Macquarie University in Sydney. Also, his support allowing me to attend various conferences and workshops was very much appreciated. Special thanks to Sebastian Richly and Sebastian Götz for initially introducing me to the very specific topic of role-based programming. The same goes to Wolfgang Lehner, who does a great job leading the RoSI research training group, and who provided me with many fruitful discussions and comments on my work. Moreover, I like to thank all the past and current colleagues for the relaxing and inter- esting research atmosphere at our chair. Off-topic chats as well as in-depth discussions about ongoing papers or my thesis were always a pleasure. As a member of the RoSI research group special thanks to Thomas, Tobias, Johannes, Steffen, and Stephan for their helpful comments and hints. Furthermore, a special thanks to Anthony Sloane for hosting me at the Macquarie University in Sydney, introducing the city to me, showing me the local highlights and providing interesting discussions about reference attribute grammars and beyond. I am also thankful to my family and friends. My parents always supported me with help, where help was needed. Thank you, Fabian, Uwe, Ronny, Felix, and Martin for all the off-topic chats and fun we had during our student times. A very special thanks goes to my girlfriend Anne, who greatly supported me during my entire PhD project. Even if she has no special interest in computer science, she always encouraged me to keep going. So I did. PUBLICATIONS Sebastian Götz, Max Leuthäuser, Christian Piechnick, Jan Reimann, Sebastian Richly, Julia Schroeter, Claas Wilke, and Uwe Aßmann. Entwicklung Cyber-Physikalischer Systeme am Beispiel des NAO-Roboters. Chemnitzer Linux-Tage - Tagungsband, 2012 Sebastian Götz, Max Leuthäuser, Jan Reimann, Julia Schroeter, Christian Wende, Claas Wilke, and Uwe Aßmann. A Role-Based Language for Collaborative Robot Applica- tions. In Leveraging Applications of Formal Methods, Verification, and Validation, ISoLA SARS, pages 1–15. Springer, 2011 Thomas Kühn, Max Leuthäuser, Sebastian Götz, Christoph Seidl, and Uwe Aßmann. A Metamodel Family for Role-Based Modeling and Programming Languages. In Benoît Combemale, DavidJ. Pearce, Olivier Barais, and JurgenJ. Vinju, editors, Soft- ware Language Engineering, volume 8706 of Lecture Notes in Computer Science, pages 141–160. Springer International Publishing, 2014. ISBN 978-3-319-11244-2. doi: 10.1007/978-3-319-11245-9_8 Max Leuthäuser. SCROLL - A Scala-based library for Roles at Runtime. In van der Storm, Tijs and Erdweg, Sebastian, editor, Proceedings of the 3rd Workshop on Domain-Specific Language Design and Implementation (DSLDI 2015), volume abs/1508.03536, pages 7–8. van der Storm, Tijs and Erdweg, Sebastian, 2015 Max Leuthäuser and Uwe Aßmann. Enabling View-based Programming with SCROLL: Using Roles and Dynamic Dispatch for Establishing View-based Programming. In Proceedings of the 2015 Joint MORSE/VAO Workshop on Model-Driven Robot Soft- ware Engineering and View-based Software-Engineering, MORSE/VAO ’15, pages 25–33, New York, NY, USA, 2015. ACM. ISBN 978-1-4503-3614-7. doi: 10.1145/ 2802059.2802062 Tobias Jäkel, Martin Weißbach, Kai Herrmann, Hannes Voigt, and Max Leuthäuser. Posi- tion Paper: Runtime Model for Role-Based Software Systems. In 2016 IEEE Interna- tional Conference on Autonomic Computing (ICAC), pages 380–387, July 2016. doi: 10.1109/ICAC.2016.17 Max Leuthäuser. Pure Embedding of Evolving Objects. In Proceedings of ADAPTIVE 2017, The Ninth International Conference on Adaptive and Self-Adaptive Systems and Applications, ADAPTIVE 2017. IARIA, 2017 CONTENTS Statement of authorship 5 Abstract 7 Acknowledgments 9 Publications 11 Contents 13 I. Introduction 15 1. Thesis Topic 17 2. Contributions and Outline 19 II. Background and Problem Analysis 21 3. Foundations of Roles 23 3.1. The Historical Term Role ................................ 23 3.2. Issues of Object-oriented Software Design .................... 24 3.3. The Introduction of Roles ............................... 25 3.4. Towards a Common Understanding of Roles ................... 27 3.5. The Compartment Role Object Model (CROM) ................. 30 3.6. The Automaton-based Role-binding Process ................... 33 3.7. Runtime-specific Role Features ........................... 34 4. Foundations of Dispatch 39 4.1. Predicate Dispatch ................................... 41 4.2. Multi-dimensional Dispatch .............................. 41 5. Foundations of Graphs and Graph Filtering 43 6. A Motivating Example for Multi-dimensional Dispatch 47 7. Research Challenges 51 III. Roles in Structured Contexts at Runtime 53 8. The Embedded DSL SCROLL 55 8.1. The Basic Ingredients of the Embedded DSL SCROLL
Load more

Recommended publications
  • Predicate Dispatching
    This pap er app ears in ECOOP the th Europ ean Conference on Ob ject Oriented Programming Brussels Belgium July pp Predicate Dispatching A Unied Theory of Dispatch Michael Ernst Craig Kaplan and Craig Chambers Department of Computer Science and Engineering University of Washington Seattle WA USA fmernstcskchambersgcswashingtonedu httpwwwcswashingtoneduresearchprojectscecil Abstract Predicate dispatching generalizes previous metho d dispatch mechanisms by p ermitting arbitrary predicates to control metho d ap plicabili ty and by using logical implication b etween predicates as the overriding relationship The metho d selected to handle a message send can dep end not just on the classes of the arguments as in ordinary ob jectoriented dispatch but also on the classes of sub comp onents on an arguments state and on relationships b etween ob jects This simple mechanism subsumes and extends ob jectoriented single and multiple dispatch MLstyle pattern matching predicate classes and classiers which can all b e regarded as syntactic sugar for predicate dispatching This pap er introduces predicate dispatching gives motivating examples and presents its static and dynamic semantics An implementation of predicate dispatching is available Introduction Many programming languages supp ort some mechanism for dividing the b o dy of a pro cedure into a set of cases with a declarative mechanism for selecting the right case for each dynamic invocation of the pro cedure Case selection can b e broken down into tests for applicability a case is a candidate
    [Show full text]
  • (Dynamic (Programming Paradigms)) Performance and Expressivity Didier Verna
    (Dynamic (programming paradigms)) Performance and expressivity Didier Verna To cite this version: Didier Verna. (Dynamic (programming paradigms)) Performance and expressivity. Software Engineer- ing [cs.SE]. LRDE - Laboratoire de Recherche et de Développement de l’EPITA, 2020. hal-02988180 HAL Id: hal-02988180 https://hal.archives-ouvertes.fr/hal-02988180 Submitted on 4 Nov 2020 HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non, lished or not. The documents may come from émanant des établissements d’enseignement et de teaching and research institutions in France or recherche français ou étrangers, des laboratoires abroad, or from public or private research centers. publics ou privés. THÈSE D’HABILITATION À DIRIGER LES RECHERCHES Sorbonne Université Spécialité Sciences de l’Ingénieur (DYNAMIC (PROGRAMMING PARADIGMS)) PERFORMANCE AND EXPRESSIVITY Didier Verna [email protected] Laboratoire de Recherche et Développement de l’EPITA (LRDE) 14-16 rue Voltaire 94276 Le Kremlin-Bicêtre CEDEX Soutenue le 10 Juillet 2020 Rapporteurs: Robert Strandh Université de Bordeaux, France Nicolas Neuß FAU, Erlangen-Nürnberg, Allemagne Manuel Serrano INRIA, Sophia Antipolis, France Examinateurs: Marco Antoniotti Université de Milan-Bicocca, Italie Ralf Möller Université de Lübeck, Allemagne Gérard Assayag IRCAM, Paris, France DOI 10.5281/zenodo.4244393 Résumé (French Abstract) Ce rapport d’habilitation traite de travaux de recherche fondamentale et appliquée en informatique, effectués depuis 2006 au Laboratoire de Recherche et Développement de l’EPITA (LRDE). Ces travaux se situent dans le domaine des langages de pro- grammation dynamiques, et plus particulièrement autour de leur expressivité et de leur performance.
    [Show full text]
  • Aspects and Polymorphism in Aspectj
    Aspects and Polymorphism in AspectJ Erik Ernst David H. Lorenz Dept. of Computer Science, College of Computer & Information Science, University of Aarhus Northeastern University Abogade˚ 34, DK­8200 Arhus˚ N 360 Huntington Avenue 161 CN Denmark Boston, Massachusetts 02115 USA [email protected] [email protected] ABSTRACT ¢ Polymorphic access: A name denotes an object whose dy- There are two important points of view on inclusion or subtype namic type is known only by an upper bound. For example, polymorphism in object-oriented programs, namely polymorphic the predefined reference self in a method in a class C de- access and dynamic dispatch. These features are essential for object- notes an instance of C or some subclass of C. The essence is oriented programming, and it is worthwhile to consider whether that the same code can operate on differently shaped objects they are supported in aspect-oriented programming (AOP). In AOP, because they all satisfy certain constraints (possibly made pieces of crosscutting behavior are extracted from the base code explicit in a statically declared type). and localized in aspects, losing as a result their polymorphic capa- ¢ Dynamic dispatch: When accessing an object polymorphi- bilities while introducing new and unexplored issues. In this paper, cally, a message-send may be resolved by late binding, i.e., we explore what kinds of polymorphism AOP languages should it may call different method implementations for different support, using AspectJ as the basis for the presentation. The results dynamic receiver types. The essence is that the meaning of are not exclusive to AspectJ—aspectual polymorphism may make a name (the method selector) is determined by dynamically aspects in any comparable AOSD language more expressive and selecting the “best” definition from a set of different avail- reusable across programs, while preserving safety.
    [Show full text]
  • Oomatch: Pattern Matching As Dispatch in Java
    OOMatch: Pattern Matching as Dispatch in Java Adam Richard Ondrejˇ Lhotak´ University of Waterloo University of Waterloo [email protected] [email protected] Abstract ther in a case statement or in a set of functions. Though this pat- We present a new language feature, specified as an extension to tern matching is useful in a functional context, simple algebraic Java. The feature is a form of dispatch, which includes and sub- types and tuples are not used much in object-oriented program- sumes multimethods (see for example [CLCM00]), but which is ming; classes are used much more. So we here present a means of not as powerful as general predicate dispatch [EKC98]. It is, how- deconstructing objects into their components and specifying pat- ever, intended to be more practical and easier to use than the latter. terns that match objects with certain properties. The extension, dubbed OOMatch, allows method parameters to be The most significant difference from pattern matching in func- specified as patterns, which are matched against the arguments to tional languages is that in OOMatch, pattern matching is used in the method call. When matches occur, the method applies; if multi- determining method dispatch. Thus, pattern precedence cannot be ple methods apply, the method with the more specific pattern over- determined by textual order, as it is in functional languages. The rides the others. patterns are specified as parameters to methods, and the compiler The pattern matching is very similar to that found in the “case” decides on a natural order to check for a matching pattern, i.e.
    [Show full text]
  • Signature Redacted Department of Electrical Engineering and Computer Science May 20, 2015
    ARCHNES Abstraction in Technical Computing MASSACHUSETTS INSTITUTE OF TECHNOLOLGY by JUL 0 7 2015 Jeffrey Werner Bezanson LIBRARIES A.B., Harvard University (2004) S.M., Massachusetts Institute of Technology (2012) Submitted to the Department of Electrical Engineering and Computer Science in partial fulfillment of the requirements for the degree of Doctor of Philosophy at the MASSACHUSETTS INSTITUTE OF TECHNOLOGY June 2015 @ Massachusetts Institute of Technology 2015. All rights reserved. Author....... Signature redacted Department of Electrical Engineering and Computer Science May 20, 2015 Certified by ............ Signature redacted ......... Alan Edelman Professor Thesis Supervisor Accepted by...... Signature redacted -6 Leslie Kolodziejski Chairman, Department Committee on Graduate Students 2 Abstraction in Technical Computing by Jeffrey Werner Bezanson Submitted to the Department of Electrical Engineering and Computer Science on May 20, 2015, in partial fulfillment of the requirements for the degree of Doctor of Philosophy Abstract Array-based programming environments are popular for scientific and technical computing. These systems consist of built-in function libraries paired with high-level languages for in- teraction. Although the libraries perform well, it is widely believed that scripting in these languages is necessarily slow, and that only heroic feats of engineering can at best partially ameliorate this problem. This thesis argues that what is really needed is a more coherent structure for this func- tionality. To find one, we must ask what technical computing is really about. This thesis suggests that this kind of programming is characterized by an emphasis on operator com- plexity and code specialization, and that a language can be designed to better fit these requirements.
    [Show full text]
  • Oomatch: Pattern Matching As Dispatch in Java
    OOMatch: Pattern Matching as Dispatch in Java by Adam Richard A thesis presented to the University of Waterloo in fulfilment of the thesis requirement for the degree of Master of Mathematics in Computer Science Waterloo, Ontario, Canada, 2007 c Adam Richard 2007 AUTHOR’S DECLARATION FOR ELECTRONIC SUBMISSION OF A THESIS I hereby declare that I am the sole author of this thesis. This is a true copy of the thesis, including any required final revisions, as accepted by my examiners. I understand that my thesis may be made electronically available to the public. ii Abstract We present a new language feature, specified as an extension to Java. The feature is a form of dispatch, which includes and subsumes multimethods (see for example [CLCM00]), but which is not as powerful as general predicate dispatch [EKC98]. It is, however, intended to be more practical and easier to use than the latter. The extension, dubbed OOMatch, allows method parameters to be specified as patterns, which are matched against the arguments to the method call. When matches occur, the method applies; if multiple methods apply, the method with the more specific pattern overrides the others. The pattern matching is very similar to that found in the “case” constructs of many functional languages (ML [MTHM97], for example), with an important difference: functional languages normally allow pattern matching over variant types (and other primitives such as tuples), while OOMatch allows pattern matching on Java objects. Indeed, the wider goal here is the study of the combination of functional and object-oriented programming paradigms. Maintaining encapsulation while allowing pattern matching is of special impor- tance.
    [Show full text]
  • Filtered Dispatch
    Filtered Dispatch Pascal Costanza Charlotte Herzeel Jorge Vallejos Theo D’Hondt Programming Technology Lab Vrije Universiteit Brussel B-1050 Brussels, Belgium pascal.costanza | charlotte.herzeel | jorge.vallejos | tjdhondt @vub.ac.be ABSTRACT (defmethod fac ((n number)) (* n (fac (- n 1)))) Predicate dispatching is a generalized form of dynamic dis- patch, which has strong limitations when arbitrary pred- (defmethod fac ((n (eql 0))) icates of the underlying base language are used. Unlike 1) classes, which enforce subset relationships between their sets of instances, arbitrary predicates generally do not designate subsets of each other, so methods whose applicability is Figure 1: Factorial as a generic function. based on predicates cannot be ordered according to their specificity in the general case. This paper introduces a de- cidable but expressive alternative mechanism called filtered Fortress [1], to name a few. The common feature in these dispatch that adds a simple preprocessing step before the ac- systems is that a generic function can select and apply meth- tual method dispatch is performed and thus enables the use ods based on the classes of the received arguments, allowing of arbitrary predicates for selecting and applying methods. users to define new methods for new classes and thus spe- cialize generic functions for their own purposes. Categories and Subject Descriptors There exist several extensions and variations of this ba- D.1 [Software]: Programming Techniques|Object-oriented sic approach, like the inclusion of aspect-style advice and Programming; D.3.3 [Programming Languages]: Lan- metaobject protocols for influencing the exact semantics of guage Constructs and Features method dispatch. A common extension is to specialize meth- ods not only on classes, but also on single objects, such that specific objects can have their own behavior that deviates Keywords from the general behavior of their classes.
    [Show full text]
  • Multijava: Design Rationale, Compiler Implementation, and Applications
    MultiJava: Design Rationale, Compiler Implementation, and Applications Curtis Clifton, Todd Millstein, Gary T. Leavens, and Craig Chambers TR #04-01b December 2004 Revised version of TR #04-01, dated January 2004 and titled MultiJava: Design Rationale, Compiler Implementation, and User Experience Keywords: Open Classes, Open Objects, Extensible Classes, Extensible Exter- nal Methods, External Methods, Multimethods, Generic Functions, Object-oriented Programming Languages, Single Dispatch, Multiple Dispatch, Encapsulation, Mod- ularity, Static Typechecking, Subtyping, Inheritance, Java Language, MultiJava Language, Separate Compilation 2002 CR Categories: D.3.1 [Programming Techniques] Object-oriented Pro- gramming; D.3.2 [Programming Languages] Language Classifications — object- oriented languages; D.3.3 [Programming Languages] Language Constructs and Fea- tures — abstract data types, classes and objects, control structures, inheritance, modules, packages, patterns, procedures, functions and subroutines; D.3.4 [Pro- gramming Languages] Processors — compilers; D.3.m [Programming Languages] Miscellaneous — generic functions, multimethods, open classes. Copyright c 2004, Curtis Clifton, Todd Millstein, Gary T. Leavens, and Craig Chambers, Submitted for Publication. Department of Computer Science 226 Atanasoff Hall Iowa State University Ames, Iowa 50011-1040, USA MultiJava: Design Rationale, Compiler Implementation, and Applications CURTIS CLIFTON Iowa State University TODD MILLSTEIN University of California, Los Angeles GARY T. LEAVENS Iowa State University and CRAIG CHAMBERS University of Washington MultiJava is a conservative extension of the Java programming language that adds symmetric multiple dispatch and open classes. Among other benefits, multiple dispatch provides a solution to the binary method problem. Open classes provide a solution to the extensibility problem of object-oriented programming languages, allowing the modular addition of both new types and new operations to an existing type hierarchy.
    [Show full text]
  • Predicate Dispatching: a Uni Ed Theory of Dispatch
    Predicate Dispatching: A Uni ed Theory of Dispatch Michael Ernst Craig Kaplan Craig Chamb ers Technical rep ort UW-CSE-98-01-0 2 Department of Computer Science and Engineering UniversityofWashington Seattle, WA, USA 98195-2350 fmernst;csk;[email protected] http://www.cs.washington.edu/research/projects/cecil/ 12 January 1998 Abstract Predicate dispatching generalizes previous metho d dispatch mechanisms by p ermitting arbitrary predicates to control metho d applicability and by using logical implication b etween predicates as the overriding relation- ship. The metho d selected to handle a message send can dep end not just on the classes of the arguments, as in ordinary ob ject-oriented dispatch, but also on the classes of sub comp onents, on an argument's state, and on relationships b etween ob jects. This simple mechanism subsumes and extends ob ject-oriented single and multiple dispatch, ML-style pattern matching, predicate classes, and classi ers, which can all b e regarded as syntactic sugar for predicate dispatching. This pap er intro duces predicate dispatching, gives motivating examples adapted from a prototyp e implementation, and presents its static and dynamic semantics. 1 Intro duction Many programming languages supp ort some mechanism for dividing the b o dy of a generic function into a set of cases, with a declarative mechanism for selecting the right case for each dynamic invo cation of the generic function. Case selection can b e broken down into tests for applicability a case is a candidate for invo cation if its guard is satis ed and overriding which selects one of the applicable cases for invo cation.
    [Show full text]
  • Simplifying the Analysis of C++ Programs
    SIMPLIFYING THE ANALYSIS OF C++ PROGRAMS A Dissertation by YURIY SOLODKYY Submitted to the Office of Graduate and Professional Studies of Texas A&M University in partial fulfillment of the requirements for the degree of DOCTOR OF PHILOSOPHY Chair of Committee, Bjarne Stroustrup Committee Members, Jaakko J¨arvi Lawrence Rauchwerger Sergiy Butenko Head of Department, Duncan M. (Hank) Walker August 2013 Major Subject: Computer Science and Engineering Copyright 2013 Yuriy Solodkyy ABSTRACT Based on our experience of working with different C++ front ends, this thesis identifies numerous problems that complicate the analysis of C++ programs along the entire spectrum of analysis applications. We utilize library, language, and tool extensions to address these problems and offer solutions to many of them. In particular, we present efficient, expressive and non-intrusive means of dealing with abstract syntax trees of a program, which together render the visitor design pattern obsolete. We further extend C++ with open multi-methods to deal with the broader expression problem. Finally, we offer two techniques, one based on refining the type system of a language and the other on abstract interpretation, both of which allow developers to statically ensure or verify various run-time properties of their programs without having to deal with the full language semantics or even the abstract syntax tree of a program. Together, the solutions presented in this thesis make ensuring properties of interest about C++ programs available to average language users. ii ACKNOWLEDGEMENTS Knowledge is in the end based on acknowledgement. Ludwig Wittgenstein This Ph.D. thesis would not have been possible without direct or indirect support of many indi- viduals who I was fortunate enough to meet through life and be friends with.
    [Show full text]
  • Modularly Typesafe Interface Dispatch in Jpred
    Modularly Typesafe Interface Dispatch in JPred Christopher Frost Todd Millstein University of California, Los Angeles ffrost,[email protected] Abstract these restrictions and modifications affect the ability to dynamically Multiple dispatch generalizes the receiver-oriented dynamic dis- dispatch on interfaces, which we term interface dispatch, greatly patch of traditional object-oriented (OO) languages by allowing the hindering that idiom despite its practical utility. run-time classes of all arguments to be employed. While research In this paper, we describe a simple but practical way to integrate over the last decade has shown how to integrate multiple dispatch multiple dispatch with multiple inheritance while preserving mod- with the modular static typechecking found in traditional OO lan- ular typechecking. Our key observation is that the notion of predi- guages, that work has been forced to impose unnatural restrictions cate dispatch [19], which generalizes multiple dispatch by guarding or modifications in order to safely accommodate multiple inheri- each method with a predicate indicating when the method should tance. In the context of Java, the effect has been to make it difficult be invoked, naturally allows potential multiple-inheritance ambigu- to dispatch on interfaces. ities to be modularly resolved without requiring extra restrictions or In this paper, we illustrate how the concept of predicate modifications. We have implemented our approach in the context of dispatch, which generalizes multiple dispatch by allowing each JPred [28], an existing extension to Java supporting predicate dis- method to be guarded by a predicate indicating when the method patch. JPred originally disallowed interface dispatch altogether be- should be invoked, provides a simple but practical way to support cause of the problems for modular typechecking, but our approach dispatch on interfaces while preserving modular typechecking.
    [Show full text]
  • Type Classes Without Types∗
    Type Classes Without Types ∗ Ronald Garcia Andrew Lumsdaine Open Systems Lab Indiana University Bloomington, IN 47405 {garcia,lums}@cs.indiana.edu Abstract ... [else (error "invalid arguments")]))) Data-directed programs consist of collections of generic functions, functions whose underlying implementation differs depending on The body of + is simply a cond expression that tests its operands properties of their arguments. Scheme’s flexibility lends itself to for various properties and dispatches to the implementation upon developing generic functions, but the language has some shortcom- finding a match. Assuming specific implementations of addition for ings in this regard. In particular, it lacks both facilities for con- integers and complex numbers, the function dispatches to integer veniently extending generic functions while preserving the flexi- addition when the operands are integers, and complex numbers bility of ad-hoc overloading techniques and constructs for group- when the operands are complex. 1 ing related generic functions into coherent interfaces. This paper For all their benefits, generic functions implemented using cond describes and discusses a mechanism, inspired by Haskell type as above have their shortcomings. Such functions are not meant to classes, for implementing generic functions in Scheme that di- be extended to support new types of arguments. Nonetheless, such rectly addresses the aforementioned concerns. Certain properties of a function may be extended at the top-level using ad-hoc means as Scheme, namely dynamic typing and an emphasis on block struc- in the following: ture, have guided the design toward an end that balances structure and flexibility. We describe the system, demonstrate its function, (define + and argue that it implements an interesting approach to polymor- (let ([old-+ +]) phism and, more specifically, overloading.
    [Show full text]