DOCSLIB.ORG

Reliably Composable Language Extensions

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Reliably Composable Language Extensions View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by University of Minnesota Digital Conservancy Reliably composable language extensions A Dissertation SUBMITTED TO THE FACULTY OF THE UNIVERSITY OF MINNESOTA BY Ted Kaminski IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE DEGREE OF DOCTOR OF PHILOSOPHY Eric Van Wyk May, 2017 Copyright © 2017 Ted Kaminski. Acknowledgments I am unlikely to do justice to everyone I should thank here. I should begin by thanking my advisor, Eric Van Wyk, who has been a been a better mentor than I had even expected going in, and I had pretty optimistic expectations. I would also like to thank my thesis committee members: Gopalan Nadathur, Mike Whalen, and Tim Hunter. All of them helped provide valuable feedback in polishing this thesis. I also want to thank my ex-committee member, Wayne Richter, who retired before I finished this thing off. I’d like to thank other students in this department, without whom grad school would hardly have been as excellent as it was: Nate Bird, Morten Warncke-Wang, Aaron Halfaker, Michael Ekstrand, Sarah McRoberts, Andy Exley, Hannah Miller, Sean Landman, Dane Coffey, Fedor Korsakov, and you know, tag yourselves. Sorry Reid. I’d also like to thank the colleagues I’ve had a chance to talk shop with, especially Tony Sloane and Jurgen Vinju. I’d like to thank math friends, Shelley Kandola and Maggie Ewing, who provided some welcome diversions into things that aren’t a part of this thesis, unfortunately. As for Minneapolis in general, best place on Earth, there are too many people to name, but Eli Cizewski-Robinson must appear here. And finally, thank you Mary Katherine Southern, best friend, girlfriend, and colleague, for your support through most of grad school, for helping me make sense of things, and for brightening my life. And a final thank you to my family, for their support as well. This material is based upon work partially supported by the National Science Foundation under Grant Nos. IIS 0905581, ACI 1047961, and CBET 1307089. I’d also like to acknowledge the support of Department of Education GAANN fellowships (through grants P200A060194 and P200A100195.) I was also partially supported in this work through DARPA and the US Air Force Research Lab under Contract No FA8650-10-C-7076, in conjunction with Adventium Labs. i Abstract Many programming tasks are dramatically simpler when an appropriate domain-specific language can be used to accomplish them. These languages of- fer a variety of potential advantages, including programming at a higher level of abstraction, custom analyses specific to the problem domain, and the ability to generate very efficient code. But they also suffer many disadvantages as a result of their implementation techniques. Fully separate languages (such as YACC, or SQL) are quite flexible, but these are distinct monolithic entities and thus we are unable to draw on the features of several in combination to accomplish a single task. That is, we cannot compose their domain-specific features. “Embedded” DSLs (such as parsing combinators) accomplish some- thing like a different language, but are actually implemented simply as libraries within a flexible host language. This approach allows different libraries to be imported and used together, enabling composition, but it is limited in analysis and translation capabilities by the host language they are embedded within. A promising combination of these two approaches is to allow a host language to be directly extended with new features (syntactic and semantic.) However, while there are plausible ways to attempt to compose language extensions, they can easily fail, making this approach unreliable. Previous methods of assuring reliable composition impose onerous restrictions, such as throwing out entirely the ability to introduce new analysis. This thesis introduces reliably composable language extensions as a tech- nique for the implementation of DSLs. This technique preserves most of the advantages of both separate and “embedded” DSLs. Unlike many prior ap- proaches to language extension, this technique ensures composition of multiple language extensions will succeed, and preserves strong properties about the ii behavior of the resulting composed compiler. We define an analysis on lan- guage extensions that guarantees the composition of several extensions will be well-defined, and we further define a set of testable properties that ensure the resulting compiler will behave as expected, along with a principle that assigns “blame” for bugs that may ultimately appear as a result of composition. Fi- nally, to concretely compare our approach to our original goals for reliably composable language extension, we use these techniques to develop an extensi- ble C compiler front-end, together with several example composable language extensions. iii Contents List of Figures x 1 Introduction 1 1.1 Domain-specific languages ........................ 3 1.2 Language composition .......................... 7 1.2.1 Composable language extensions ................ 8 1.3 Motivation for composable language extension . 11 1.4 Contributions ............................... 14 1.5 Outline of the thesis ........................... 17 2 Related work 20 2.1 Extensible languages, historically .................... 21 2.2 The expression problem ......................... 23 2.3 Language specification systems ..................... 25 2.3.1 Objects .............................. 26 2.3.2 Algebraic datatypes ........................ 27 2.3.3 Systems that have solved the expression problem . 28 2.3.4 Macros ............................... 30 2.3.5 Common host languages for internal DSLs . 32 iv Contents 3 Background 35 3.1 Attribute grammars ............................ 36 3.1.1 Higher-order attribute grammars . 39 3.1.2 Forwarding ............................ 42 3.1.3 Reference attribute grammars . 46 3.1.4 Aspects .............................. 48 3.1.5 Remote/collection attributes ................... 50 3.1.6 Well-definedness .......................... 51 3.2 Silver .................................... 52 3.3 Copper ................................... 53 4 Integrating AGs and functional programming 56 4.1 Language Design Goals .......................... 58 4.2 The Ag Language ............................. 59 4.2.1 Decorated and undecorated trees . 65 4.2.2 Semantics ............................. 68 4.3 The Type System ............................. 73 4.3.1 Generalized algebraic data types. 80 4.3.2 Polymorphic attribute access problem . 82 4.3.3 Putting types to work ...................... 85 4.4 Pattern Matching ............................. 87 4.4.1 Behavior .............................. 90 4.4.2 Typing pattern matching expressions . 92 4.4.3 Semantics ............................. 95 4.4.4 Towards semantics without the variable restriction . 98 v Contents 4.4.5 Differences between Ag and Silver . 100 4.5 Algebraic properties of language extension . 101 4.6 Related work ............................... 103 5 Modular well-definedness analysis 105 5.1 Modules .................................. 106 5.2 Modular analysis ............................. 109 5.3 Effective completeness and flow types . 112 5.3.1 Flow types ............................. 114 5.4 Overview of the analysis . 117 5.4.1 Restrictions imposed by the analysis . 118 5.4.2 Reasoning about the presence of inherited equations . 122 5.4.3 Integrating flow and effective completeness analysis . 124 5.5 Flow type inference ............................ 125 5.5.1 The structure of production flow graphs . 126 5.5.2 Flow dependencies of expressions . 133 5.5.3 Computing intermediate flow data . 137 5.5.4 Constructing static production flow graphs . 143 5.5.5 Computing flow types . 147 5.6 Checking for effective completeness . 150 5.6.1 Effective inherited completeness . 151 5.6.2 Implementation notes . 156 5.6.3 Extending to additional language features . 157 5.7 Self-evaluation on Silver . 159 5.8 Extending to circularity . 163 vi Contents 5.8.1 Discussion ............................. 166 5.9 Related work ............................... 168 6 Non-interference 170 6.1 The problem ................................ 173 6.2 Reasoning about attribute grammars . 175 6.2.1 Properties of languages and modular non-interference . 176 6.2.2 Induction on decorated trees . 178 6.2.3 Extending proofs to extended languages . 183 6.3 Coherence ................................. 186 6.3.1 Examples of incoherence . 189 6.3.2 Closure properties of coherence . 191 6.3.3 Restricted propositions and relations (Limitations and scope of this development) . 192 6.3.4 The problem of equality . 196 6.3.5 Non-interference: coherence over extended languages . 199 6.3.6 Coherence assures modular non-interference . 201 6.4 Showing non-interference . 204 6.4.1 An “unreasonable” approach to enforcement . 206 6.4.2 Relationship to macro systems . 211 6.5 Attribute properties: more useful non-interference . 213 6.5.1 Host language adaptation . 213 6.5.2 Weakening the strict equality condition . 215 6.5.3 Closing the world . 217 6.5.4 Summary ............................. 219 vii Contents 6.6 Property testing .............................. 220 6.7 Application to a real compiler . 223 6.8 Related work ............................... 225 6.9 Discussion ................................. 227 6.9.1 Future work ............................ 228 7 AbleC: Synthesis, Platform, and Evaluation 230 7.1 The AbleC compiler . 232 7.2 Permitted classes of language extensions . 234 7.2.1 External DSLs . 235 7.2.2 Improving
Load more

Recommended publications
  • Structuring Languages As Object-Oriented Libraries
    Structuring Languages as Object-Oriented Libraries Structuring Languages as Object-Oriented Libraries ACADEMISCH PROEFSCHRIFT ter verkrijging van de graad van doctor aan de Universiteit van Amsterdam op gezag van de Rector Magnificus prof. dr. ir. K. I. J. Maex ten overstaan van een door het College voor Promoties ingestelde commissie, in het openbaar te verdedigen in de Agnietenkapel op donderdag november , te . uur door Pablo Antonio Inostroza Valdera geboren te Concepción, Chili Promotiecommissie Promotores: Prof. Dr. P. Klint Universiteit van Amsterdam Prof. Dr. T. van der Storm Rijksuniversiteit Groningen Overige leden: Prof. Dr. J.A. Bergstra Universiteit van Amsterdam Prof. Dr. B. Combemale University of Toulouse Dr. C. Grelck Universiteit van Amsterdam Prof. Dr. P.D. Mosses Swansea University Dr. B.C.d.S. Oliveira The University of Hong Kong Prof. Dr. M. de Rijke Universiteit van Amsterdam Faculteit der Natuurwetenschappen, Wiskunde en Informatica The work in this thesis has been carried out at Centrum Wiskunde & Informatica (CWI) under the auspices of the research school IPA (Institute for Programming research and Algorith- mics) and has been supported by NWO, in the context of Jacquard Project .. “Next Generation Auditing: Data-Assurance as a Service”. Contents Introduction .Language Libraries . .Object Algebras . .Language Libraries with Object Algebras . .Origins of the Chapters . .Software Artifacts . .Dissertation Structure . Recaf: Java Dialects as Libraries .Introduction . .Overview.................................... .Statement Virtualization . .Full Virtualization . .Implementation of Recaf . .Case Studies . .Discussion . .Related Work . .Conclusion . Tracing Program Transformations with String Origins .Introduction . .String Origins . .Applications of String Origins . .Implementation . .Related Work . .Conclusion . Modular Interpreters with Implicit Context Propagation .Introduction . .Background . v Contents .Implicit Context Propagation .
    [Show full text]
  • Composable Compilers: Evolution Toward a Practical Reality
    COMPOSABLE COMPILERS: EVOLUTION TOWARD A PRACTICAL REALITY A Dissertation Presented to the Faculty of the Graduate School of Cornell University in Partial Fulfillment of the Requirements for the Degree of Doctor of Philosophy by Chinawat Isradisaikul August 2017 c 2017 Chinawat Isradisaikul COMPOSABLE COMPILERS: EVOLUTION TOWARD A PRACTICAL REALITY Chinawat Isradisaikul, Ph.D. Cornell University 2017 The ability to add new features to programming languages is essential for language design experimentation and domain-specific developments, but implementing and maintaining small language extensions in traditional compilers remain a challenge. General-purpose programming languages do not have desired mechanisms to integrate small, indepen- dently developed extensions into a working programming language. At the same time, domain-specific languages that support such integration struggle to gain popularity in the programming language community. More language mechanisms and tools are needed as a middle ground so that a broader range of programmers can implement, maintain, and combine compilers for individual language features more easily. At the heart of compiler construction, new design patterns are proposed to allow compilers to be extended in a modular way and to be merged with little effort. These design patterns, implementable in a mainstream programming language, encode dynamic relationships between node types in abstract syntax trees (ASTs) so that inheritance in object-oriented programming still works over the course of language evolution. A new AST representation lets a single AST be viewed as different programs for different languages. Compiler passes are language-neutral, making translations reusable and composable. At the front end, engineering language syntax can be a painstaking process, espe- cially when individual language syntaxes start to interact.
    [Show full text]
  • A History of Clojure
    A History of Clojure RICH HICKEY, Cognitect, Inc., USA Shepherd: Mira Mezini, Technische Universität Darmstadt, Germany Clojure was designed to be a general-purpose, practical functional language, suitable for use by professionals wherever its host language, e.g., Java, would be. Initially designed in 2005 and released in 2007, Clojure is a dialect of Lisp, but is not a direct descendant of any prior Lisp. It complements programming with pure functions of immutable data with concurrency-safe state management constructs that support writing correct multithreaded programs without the complexity of mutex locks. Clojure is intentionally hosted, in that it compiles to and runs on the runtime of another language, such as the JVM. This is more than an implementation strategy; numerous features ensure that programs written in Clojure can leverage and interoperate with the libraries of the host language directly and efficiently. In spite of combining two (at the time) rather unpopular ideas, functional programming and Lisp, Clojure has since seen adoption in industries as diverse as finance, climate science, retail, databases, analytics, publishing, healthcare, advertising and genomics, and by consultancies and startups worldwide, much to the career-altering surprise of its author. Most of the ideas in Clojure were not novel, but their combination puts Clojure in a unique spot in language design (functional, hosted, Lisp). This paper recounts the motivation behind the initial development of Clojure and the rationale for various design decisions and language constructs. It then covers its evolution subsequent to release and adoption. CCS Concepts: • Software and its engineering ! General programming languages; • Social and pro- fessional topics ! History of programming languages.
    [Show full text]
  • Good Advice for Type-Directed Programming
    Good Advice for Type-directed Programming Aspect-oriented Programming and Extensible Generic Functions Geoffrey Washburn Stephanie Weirich University of Pennsylvania {geoffw,sweirich}@cis.upenn.edu ABSTRACT of type-directed combinators to “scrap” this boilerplate. For Type-directed programming is an important idiom for soft- example, L¨ammeland Peyton Jones’s Haskell library pro- ware design. In type-directed programming the behavior of vides a combinator called gmapQ that maps a query over programs is guided by the type structure of data. It makes an arbitrary value’s children returning a list of the results. it possible to implement many sorts of operations, such as Using gmapQ it becomes trivial to implement a type-directed serialization, traversals, and queries, only once and without function, gsize, to compute the size of an arbitrary value. needing to continually revise their implementation as new gsize :: Data a => a -> Int data types are defined. gsize x = 1 + sum (gmapQ gsize x) Type-directed programming is the basis for recent research into “scrapping” tedious boilerplate code that arises in func- However, this line of research focused on closed type- tional programming with algebraic data types. This research directed functions. Closed type-directed functions require has primarily focused on writing type-directed functions that that all cases be defined in advance. Consequently, if the are closed to extension. However, L¨ammel and Peyton Jones programmer wanted gsize to behave in a specialized fashion recently developed a technique for writing openly extensible for one of their data types, they would need to edit the type-directed functions in Haskell by making clever use of definition of gmapQ.
    [Show full text]
  • Functional Programming Patterns in Scala and Clojure Write Lean Programs for the JVM
    Early Praise for Functional Programming Patterns This book is an absolute gem and should be required reading for anybody looking to transition from OO to FP. It is an extremely well-built safety rope for those crossing the bridge between two very different worlds. Consider this mandatory reading. ➤ Colin Yates, technical team leader at QFI Consulting, LLP This book sticks to the meat and potatoes of what functional programming can do for the object-oriented JVM programmer. The functional patterns are sectioned in the back of the book separate from the functional replacements of the object-oriented patterns, making the book handy reference material. As a Scala programmer, I even picked up some new tricks along the read. ➤ Justin James, developer with Full Stack Apps This book is good for those who have dabbled a bit in Clojure or Scala but are not really comfortable with it; the ideal audience is seasoned OO programmers looking to adopt a functional style, as it gives those programmers a guide for transitioning away from the patterns they are comfortable with. ➤ Rod Hilton, Java developer and PhD candidate at the University of Colorado Functional Programming Patterns in Scala and Clojure Write Lean Programs for the JVM Michael Bevilacqua-Linn The Pragmatic Bookshelf Dallas, Texas • Raleigh, North Carolina Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and The Pragmatic Programmers, LLC was aware of a trademark claim, the designations have been printed in initial capital letters or in all capitals.
    [Show full text]
  • Extensibility for the Masses Practical Extensibility with Object Algebras
    Extensibility for the Masses Practical Extensibility with Object Algebras Bruno C. d. S. Oliveira1 and William R. Cook2 1 Seoul National University [email protected] 2 University of Texas, Austin [email protected] Abstract. This paper presents a new solution to the expression problem (EP) that works in OO languages with simple generics (including Java or C#). A key novelty of this solution is that advanced typing features, including F-bounded quantification, wildcards and variance annotations, are not needed. The solution is based on object algebras, which are an abstraction closely related to algebraic datatypes and Church encodings. Object algebras also have much in common with the traditional forms of the Visitor pattern, but without many of its drawbacks: they are extensible, remove the need for accept methods, and do not compromise encapsulation. We show applications of object algebras that go beyond toy examples usually presented in solutions for the expression problem. In the paper we develop an increasingly more complex set of features for a mini-imperative language, and we discuss a real-world application of object algebras in an implementation of remote batches. We believe that object algebras bring extensibility to the masses: object algebras work in mainstream OO languages, and they significantly reduce the conceptual overhead by using only features that are used by everyday programmers. 1 Introduction The “expression problem” (EP) [37,10,45] is now a classical problem in program- ming languages. It refers to the difficulty of writing data abstractions that can be easily extended with both new operations and new data variants.
    [Show full text]
  • The Joy of Clojure by Michael Fogus and Chris Houser
    Michael Fogus Chris Houser FOREWORD BY STEVE YEGGE MANNING The Joy of Clojure by Michael Fogus and Chris Houser Chapter 1 Copyright 2011 Manning Publications brief contents PART 1 FOUNDATIONS ......................................................................1 1 ■ Clojure philosophy 3 2 ■ Drinking from the Clojure firehose 20 3 ■ Dipping our toes in the pool 43 PART 2 DATA TYPES ........................................................................59 4 ■ On scalars 61 5 ■ Composite data types 76 PART 3 FUNCTIONAL PROGRAMMING............................................. 105 6 ■ Being lazy and set in your ways 107 7 ■ Functional programming 125 PART 4 LARGE-SCALE DESIGN ........................................................ 155 8 ■ Macros 157 9 ■ Combining data and code 177 10 ■ Java.next 207 11 ■ Mutation 234 PART 5 TANGENTIAL CONSIDERATIONS.......................................... 275 12 ■ Performance 277 13 ■ Clojure changes the way you think 292 vii Clojure philosophy This chapter covers The Clojure way Why a(nother) Lisp? Functional programming Why Clojure isn’t especially object-oriented Learning a new language generally requires significant investment of thought and effort, and it is only fair that programmers expect each language they consider learning to justify that investment. Clojure was born out of creator Rich Hickey’s desire to avoid many of the complications, both inherent and incidental, of manag- ing state using traditional object-oriented techniques. Thanks to a thoughtful design based in rigorous programming language research, coupled with a fervent look toward practicality, Clojure has blossomed into an important programming language playing an undeniably important role in the current state of the art in lan- guage design. On one side of the equation, Clojure utilizes Software Transactional Memory (STM), agents, a clear distinction between identity and value types, arbi- trary polymorphism, and functional programming to provide an environment con- ducive to making sense of state in general, and especially in the face of concurrency.
    [Show full text]
  • CS 251: Programming Languages Fall 2015 Ruby/OOP Summary, Part 2
    CS 251: Programming Languages Fall 2015 Ruby/OOP Summary, Part 2 These notes are adapted from CSE 341 at the University of Washington, by Dan Grossman. Contents OOP Versus Functional Decomposition ................................ 1 Extending the Code With New Operations or Variants ...................... 4 Binary Methods With Functional Decomposition .......................... 6 Binary Methods in OOP: Double Dispatch .............................. 7 Multimethods ................................................ 11 Multiple Inheritance ............................................ 11 Mixins ..................................................... 13 Java/C#-Style Interfaces ......................................... 16 Abstract Methods .............................................. 16 Introduction to Subtyping ........................................ 17 A Made-Up Language of Records .................................... 18 Wanting Subtyping ............................................. 19 The Subtyping Relation .......................................... 19 Depth Subtyping: A Bad Idea With Mutation ........................... 20 The Problem With Java/C# Array Subtyping ........................... 21 Function Subtyping ............................................. 22 Subtyping for OOP ............................................. 25 Covariant self/this ............................................. 26 Generics Versus Subtyping ........................................ 26 Bounded Polymorphism .......................................... 29 Optional:
    [Show full text]
  • Feature-Oriented Programming with Object Algebras
    View metadata, citation and similar papers at core.ac.uk brought to you by CORE provided by CWI's Institutional Repository Feature-Oriented Programming with Object Algebras Bruno C.d.S. Oliveira1, Tijs van der Storm2, Alex Loh3, William R. Cook3 1National University of Singapore ([email protected]) 2Centrum Wiskunde & Informatica (CWI) ([email protected]) 3 University of Texas, Austin ({wcook,alexloh}@cs.utexas.edu) Abstract. Object algebras are a new programming technique that en- ables a simple solution to basic extensibility and modularity issues in programming languages. While object algebras excel at defining modu- lar features, the composition mechanisms for object algebras (and fea- tures) are still cumbersome and limited in expressiveness. In this paper we leverage two well-studied type system features, intersection types and type-constructor polymorphism, to provide object algebras with expres- sive and practical composition mechanisms. Intersection types are used for defining expressive run-time composition operators (combinators) that produce objects with multiple (feature) interfaces. Type-constructor polymorphism enables generic interfaces for the various object algebra combinators. Such generic interfaces can be used as a type-safe front end for a generic implementation of the combinators based on reflection. Ad- ditionally, we also provide a modular mechanism to allow different forms of self -references in the presence of delegation-based combinators. The result is an expressive, type-safe, dynamic, delegation-based composition technique for object algebras, implemented in Scala, which effectively enables a form of Feature-Oriented Programming using object algebras. 1 Introduction Feature-oriented programming (FOP) is a vision of programming in which in- dividual features can be defined separately and then composed to build a wide variety of particular products [5,21,43].
    [Show full text]
  • Clojerl: the Expressive Power of Clojure on the BEAM
    Clojerl: The Expressive Power of Clojure on the BEAM Juan Facorro Natalia Chechina Stockholm, Sweden Bournemouth University [email protected] Bournemouth, United Kindgdom [email protected] Abstract 1 Introduction The development of new features and approaches in pro- In the past couple of decades platforms built around virtual gramming languages is a continuous and never-ending task, machines and language engines, such as the Java Virtual as languages are ultimately tools for expressing and solving Machine (JVM), the Erlang VM (BEAM), .NET’s Common problems. The past decade has seen a surge in languages Language Runtime (CLR), and Javascript’s V8 Engine, have implemented for the BEAM as part of a search to combine grown and matured into ecosystems of tools and libraries. the fault-tolerance and scalability of the BEAM with a set of These platforms have also enabled and encouraged the imple- desired language features. mentation of programming languages other than the official In this paper we present Clojerl, an implementation of the group supported by each platform. As a result, people look- Clojure language with a rich set of data processing capabil- ing to take the best from the two worlds, combining their ities and the expressive power of Lisp for the BEAM. The language of choice with the power of a specific platform, main design principles of Clojerl are to provide (1) seam- have created new language implementations. less interoperability with the BEAM to enable frictionless A programming language is ultimately just a tool for solv- interaction with other BEAM languages and (2) portability ing problems.
    [Show full text]
  • Typed First-Class Traits
    Typed First-Class Traits Xuan Bi The University of Hong Kong, Hong Kong, China [email protected] Bruno C. d. S. Oliveira The University of Hong Kong, Hong Kong, China [email protected] Abstract Many dynamically-typed languages (including JavaScript, Ruby, Python or Racket) support first-class classes, or related concepts such as first-class traits and/or mixins. In those languages classes are first-class values and, like any other values, they can be passed as an argument, or returned from a function. Furthermore first-class classes support dynamic inheritance: i.e. they can inherit from other classes at runtime, enabling programmers to abstract over the inheritance hierarchy. In contrast, type system limitations prevent most statically-typed languages from having first-class classes and dynamic inheritance. This paper shows the design of SEDEL: a polymorphic statically-typed language with first- class traits, supporting dynamic inheritance as well as conventional OO features such as dynamic dispatching and abstract methods. To address the challenges of type-checking first-class traits, SEDEL employs a type system based on the recent work on disjoint intersection types and dis- joint polymorphism. The novelty of SEDEL over core disjoint intersection calculi are source level features for practical OO programming, including first-class traits with dynamic inherit- ance, dynamic dispatching and abstract methods. Inspired by Cook and Palsberg’s work on the denotational semantics for inheritance, we show how to design a source language that can be elaborated into Alpuim et al.’s Fi (a core polymorphic calculus with records supporting disjoint polymorphism). We illustrate the applicability of SEDEL with several example uses for first- class traits, and a case study that modularizes programming language interpreters using a highly modular form of visitors.
    [Show full text]
  • Concepts in Programming Languages
    Concepts in Programming Languages Alan Mycroft1 Computer Laboratory University of Cambridge CST Paper 7: 2017–2018 (Easter Term) www.cl.cam.ac.uk/teaching/1718/ConceptsPL/ 1Acknowledgement: various slides are based on Marcelo Fiore’s 2013/14 course. 1 / 240 Practicalities I Course web page: www.cl.cam.ac.uk/teaching/1718/ConceptsPL/ with lecture slides, exercise sheet and reading material. These slides play two roles – both “lecture notes" and “presentation material”; not every slide will be lectured in detail. I There are various code examples (particularly for JavaScript and Java applets) on the ‘materials’ tab of the course web page. I One exam question. I The syllabus and course has changed somewhat from that of 2015/16. I would be grateful for comments on any remaining ‘rough edges’, and for views on material which is either over- or under-represented. 2 / 240 Main books I J. C. Mitchell. Concepts in programming languages. Cambridge University Press, 2003. I T.W. Pratt and M. V.Zelkowitz. Programming Languages: Design and implementation (3RD EDITION). Prentice Hall, 1999. ? M. L. Scott. Programming language pragmatics (4TH EDITION). Elsevier, 2016. I R. Harper. Practical Foundations for Programming Languages. Cambridge University Press, 2013. 3 / 240 Context: so many programming languages Peter J. Landin: “The Next 700 Programming Languages”, CACM (published in 1966!). Some programming-language ‘family trees’ (too big for slide): http://www.oreilly.com/go/languageposter http://www.levenez.com/lang/ http://rigaux.org/language-study/diagram.html http://www.rackspace.com/blog/ infographic-evolution-of-computer-languages/ Plan of this course: pick out interesting programming-language concepts and major evolutionary trends.
    [Show full text]