DOCSLIB.ORG

Defusing the Debugging Scandal - Dedicated Debugging Technologies for Advanced Dispatching Languages

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Defusing the Debugging Scandal - Dedicated Debugging Technologies for Advanced Dispatching Languages Dedicated Debugging Technologies for Advanced Dispatching Languages Haihan Yin Haihan Languages Dispatching Advanced for Technologies Debugging Dedicated Defusing the Debugging Scandal - Dedicated Debugging Technologies for Advanced Dispatching Languages ISBN 978-90-365-3569-4 Haihan Yin Defusing the Debugging Scandal - Dedicated Debugging Technologies for Advanced Dispatching Languages Haihan Yin Ph.D dissertation committee: Chairman and secretary: Prof. Dr. Ir. A.J. Mouthaan, University of Twente, The Netherlands Promoter: Prof. Dr. Ir. Mehmet Ak¸sit, University of Twente, The Netherlands Assistant promoter: Dr. Ing. Christoph Bockisch, University of Twente, The Netherlands Members: Prof. Shigeru Chiba, University of Tokyo, Japan Prof. Jianjun Zhao, Shanghai Jiao Tong University, China Prof. Dr. Eric Bodden, Technische Universit¨atDarmstadt, Germany Prof. Dr. Jaco van de Pol, University of Twente, The Netherlands Dr. Ir. Maurice van Keulen, University of Twente, The Netherlands CTIT Ph.D. Thesis Series No. 10-170 Centre for Telematics and Information Technology P.O. Box 217, 7500 AE Enschede, The Netherlands The work described in this thesis was performed at the Software Engineering group, Center for Telematics and Information Te Technology, Faculty of Electrical Engineering, Mathematics and Computer Science, University of Twente, The Netherlands. ISBN 978-90-365-3569-4 ISSN 1381-3617 (CTIT Ph.D. thesis Series No. 10-170). DOI 10.3990./1.9789036535694 Cover designed by Haihan Yin Printed by Ipskamp Drukkers B.V., Enschede, The Netherlands Copyright c 2013, Haihan Yin, Enschede, The Netherlands All rights reserved. DEFUSING THE DEBUGGING SCANDAL - DEDICATED DEBUGGING TECHNOLOGIES FOR ADVANCED DISPATCHING LANGUAGES DISSERTATION to obtain the degree of doctor at the University of Twente, on the authority of the rector magnificus, Prof. Dr. H. Brinksma, on account of the decision of the graduation committee, to be publicly defended on Wednesday the 4th of December 2013 at 12.45 by Haihan Yin born on the 21st of June 1986 in Changsha, China This dissertation is approved by Prof. Dr. Ir. Mehmet Ak¸sit (promoter) Dr. Ing. Christoph Bockisch (assistant promoter) To my parent Jianwei and Chunhui Abstract To increase program modularity, new programming paradigms, such as aspect- oriented programming, context-oriented programming, and predicated dispatch- ing, have been researched in recent years. The new-paradigm languages allow changing behavior according to various kinds of contexts at the call sites. A re- cent statistics shows that at least 66% of skilled engineers world-wide, courses and third party vendors are using languages that support AOP features. Many well-known companies are using these languages in product developments. In our research, we classified these new languages as advanced-dispatching languages. Advanced-dispatching languages are usually implemented as an ex- tension of main-stream languages. After compilation, their programs are trans- formed to the compiled form of the main-stream language. Due to this com- pilation mechanism, the information, especially features that are specific to the advanced-dispatching languages, existing in the source code cannot be fully re- stored during debugging. The information loss increases the effort of compre- hending advanced-dispatching programs and fixing advanced-dispatching-specific defects. In this thesis, we performed four works to improve the comprehensi- bility of debugging information from three debugging techniques | interactive debugging, trace-based debugging, and slicing. We first performed research on the most common debugging technique| interactive debugging. Due to the availability of existing fault models, we pro- posed a generalized fault model based on four aspect-oriented-specific fault mod- els. The generalized fault model consists of seven fault types and we found a likely pattern for fixing a defect corresponding to each type. Then, we analysed the pattern description and extracted eleven atomic advanced-dispatching-specific debugging tasks. To support the tasks, we modified an existing compiler to keep aspect-oriented information after the compilation, built a dedicated advanced dispatching debugging model, and implemented graphical user interfaces. In addition to the form of debugging information, we analysed the problem where and when the program should be suspended. In interactive debugging, breakpoints are essential to determine the suspending places. For fixing a spe- cific defect, breakpoints are logically related. However, existing debuggers do not support to build logic between breakpoints. Therefore, programmers have to manually perform some repeated tasks. In this thesis, we analysed five common debugging scenarios that require multiple breakpoints. Targeting the investigated scenarios, we designed and implemented a breakpoint language that uses point- cuts to select suspension times in the program. In our language, an expected suspension can be expressively programmed and reached with less or even no irrelevant suspensions. Though the interactive debugging is the most commonly used debugging tech- nique, it becomes handicapped in cases that the observed failure is far away from the defect. Locating the defect is typically a backtracking process through the execution history. However, interactive debugging is performed along with the program execution and cannot restore a past state. Trace-based debugger records events at runtime and supports inspection offline. Existing researches on trace- based debugging for advanced-dispatching languages are limited. We proposed a dedicated trace-based debugger with an user interface that allow programmers to navigate and query the recorded trace. Automation is what software aims for. Slicing is a debugging technique which automatically selects program statements that can influence the failure. It is per- formed on dependency graphs that contain the inter-relationships between pro- gram statements, such as control dependencies, call dependencies. We discussed how three aspect-oriented-specific constructs, which are join point shadows, pro- gram compositions, and non-argument context values, can influence the execution of aspect-oriented programs. Considering the three constructs, we developed de- pendency graphs that are dedicated to aspect-oriented programs, as well as a slicing algorithm that is performed on the developed dependency graphs. We showed that our approach can be applied efficiently for small projects and is able to select all relevant source code. The three debugging techniques analysed in this thesis fully cover phases before, during and after the program execution. For each technique, we have pro- vided a debugging model that explicitly models advanced-dispatching concepts. The generated debugging information is in terms of advanced-dispatching abstrac- tions. Thus, the comprehensibility of debugging advanced-dispatching programs is increased. Acknowledgements Life is like a running program with occasional failures. Some people choose to ignore failures and live an easy life. In the end, those failures may deviate their lives from what they expected further and further. Some people choose to discover the cause, eliminate such failures, and live happily ever after. I started my PhD journey in 2010 October. Since then, failures have never ceased to accompany with me. People around me gave me guidances and supports to overcome these failure. This thesis belongs to everyone who ever helped me. First, I would like to appreciate my promoter Mehmet Ak¸sitto offer me the opportunity to work in the software engineering group as a PhD student. Your insightful guidance showed me promising directions to work on. You have always been a great source of inspiration for me. Christoph Bockisch is my daily supervisor during my entire PhD phase and he is also the supervisor of my master project. No word can describe how I am grateful about what he contributed to my work. There is a saying in China, \Even if someone is your teacher for only a day, you should regard him like your father for the rest of your life." Interestingly, people call a supervisor as \PhD father" in German. You are always patient to listen to my thoughts even they are simple and naive. You always encourage me even though I sometimes submitted really unsatisfied work. You are the one who can always make time for me even for unexpected visits. You always explain things step by step and teach me things hand by hand. In the third round submission to AOSD'12, we had discussion almost every day and you were extremely strict with the quality of the paper. I wrote a crucial section with only two pages eleven times. As a result, our paper not only got accepted but also won the \best paper" award. It was a great encouragement to me and I became much more confident since then. What I learnt from you is not only about research and knowledge, but also the German way of thinking and working. I digested your way of supervision and successfully applied it to three master students, including two Chinese students. It is my great fortune to choose you as my supervisor. I wish you, your wife, cute Julia, lovely Sarah, and your families all the best. Prost! I also would like to thank the members of my PhD committee: prof. Shigeru Chiba, prof. Jianjun Zhao, prof.dr. Eric Bodden, dr.ir. Maurice van Keulen, prof.dr. Jaco van de Pol. I am very honored that you accepted our invitation to be part of my committee and thank you for reading my thesis and providing valuable feedback
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]
  • 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.
    [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]