DOCSLIB.ORG

Types in the Modelica Language

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Types in the Modelica Language Types in the Modelica Language Types in the Modelica Language David Broman Peter Fritzson S¶ebastien Furic LinkÄoping University, Sweden LinkÄoping University, Sweden Imagine, France [email protected] [email protected] Abstract types and type systems. This may result in incom- patible compilers and unexpected behavior when Modelica is an object-oriented language designed using the language. for modeling and simulation of complex physical systems. To enable the possibility for an engineer The purpose of this paper is twofold. The ¯rst to discover errors in a model, languages and com- part gives an overview of the concept of types, pilers are making use of the concept of types and states concrete de¯nitions, and explains how this type checking. This paper gives an overview of relates to the Modelica language. Hence, the ¯rst the concept of types in the context of the Model- goal is to augment the computer science perspec- ica language. Furthermore, a new concrete syntax tive of language design among the individuals in- for describing Modelica types is given as a starting volved in the Modelica language design. The long- point to formalize types in Modelica. Finally, it is term objective of this work is to provide aids for concluded that the current state of the Modelica further design considerations when developing, en- language speci¯cation is too informal and should hancing and simplifying the Modelica language. in the long term be augmented by a formal de¯n- The intended audience is consequently engineers ition. and computer scientists interested in the founda- tion of the Modelica language. Keywords: type system; types; Modelica; simula- tion; modeling; type safety The second purpose and likewise the main con- tribution of this work is the de¯nition of a concrete 1 Introduction syntax for describing Modelica types. This syntax together with rules of its usage can be seen as a One long term goal of modeling and simulation starting point to more formally describe the type languages is to give engineers the possibility to concept in the Modelica language. To the best of discover modeling errors at an early stage, i.e., our knowledge, no work has previously been done to discover problems in the model during design to formalize the type concept of the Modelica lan- and not after simulation. This kind of veri¯ca- guage. tion is traditionally accomplished by the use of types in the language, where the process of check- The paper is structured as follows: Section 2 ing for such errors by the compiler is called type outlines the concept of types, subtypes, type sys- checking. However, the concept of types is of- tems and inheritance, and how these concepts are ten not very well understood outside parts of the used in Modelica and other mainstream languages. computer science community, which may result in Section 3 gives an overview of the three main forms misunderstandings when designing new languages. of polymorphism, and how these concepts corre- Why is then types important? Types in program- late with each other and the Modelica language. ming languages serve several important purposes The language concepts and de¯nitions introduced such as naming of concepts, providing the com- in Section 2 and 3 are necessary to understand the piler with information to ensure correct data ma- rest of the paper. Section 4 introduces the type nipulation, and enabling data abstraction. Almost concept of Modelica more formally, where we give all programming or modeling languages provide a concrete syntax for expressing Modelica types. some kind of types. However, few language spec- Finally, Section 5 state concluding remarks and i¯cations include precise and formal de¯nitions of propose future work in the area. The Modelica Association 303 Modelica 2006, September 4th – 5th D. Broman, P. Fritzson, S. Furic 2 Types, Subtyping and by the run-time system or by a language con- Inheritance struct, such as exception handling. A programming language is said to be safe if no There exist several models of representing types, untrapped errors are allowed to occur. These where the ideal model [3] is one of the most well- checks can be performed as compile-time checks, known. In this model, there is a universe V of all also called static checks, where the compiler ¯nds values, containing all values of integers, real num- the potential errors and reports them to the pro- bers, strings and data structures such as tuples, grammer. Some errors, such as array out of bound records and functions. Here, types are de¯ned as errors are hard to resolve statically. Therefore, sets of elements of the universe V. There is in¯- most languages are also using run-time checks, nite number of types, but all types are not legal also called dynamic checking. However, note that types in a programming language. All legal types the distinction between compile-time and run-time holding some speci¯c property, such as being an becomes vaguer when the language is intended for unsigned integer, are called ideals. Figure 1 gives interpretation. an example of the universe V and two ideals: real Typed languages can enforce language safety type and function type, where the latter has the by making sure that well-typed programs cannot domain of integer and codomain of boolean. cause type errors. Such a language is often called type safe or strongly typed. This checking process is called type checking and can be carried out both at run-time and compile-time. The behavior of the types in a language is ex- pressed in a type system. A type system can be described informally using plain English text, Figure 1: Schematic illustration of Universe V and or formally using type rules. The Modelica lan- two ideals. guage speci¯cation is using the former informal approach. Formal type rules have much in com- In most mainstream languages, such as Java and mon with logical inference rules, and might at C++, types are explicitly typed by stating infor- ¯rst glance seem complex, but are fairly straight- mation in the syntax. In other languages, such as forward once the basic concepts are understood. Standard ML and Haskell, a large portion of types Consider the following: can be inferred by the compiler, i.e., the compiler deduces the type from the context. This process is referred to as type inference and such a language G ` e1 : bool G ` e2 : T G ` e3 : T (t-if) is said to be implicitly typed. Modelica is an ex- G ` if e1 then e2 else e3 : T plicitly typed language. which illustrates a type rule for the following Mod- 2.1 Language Safety and Type Systems elica if-expression: if e1 then e2 else e3 When a program is executed, or in the Modelica case: during simulation, di®erent kinds of execu- A type rule is written using a number of premises tion errors can take place. It is practical to distin- located above the horizontal line and a conclusion guish between the following two types of runtime below the line. The typing judgement G ` e : T errors [2]. means that expression e has type T with respect to a static typing environment . Hence, the rule ² Untrapped errors are errors that can go un- G (t-if) states that guard e must have the type of noticed and later cause arbitrary behavior of 1 a boolean and that e and e must have the same the system. For example, writing data out of 2 3 type, which is also the resulting type of the if- bound of an array might not result in an im- expression after evaluation. This resulting type is mediate error, but the program might crash stated in the last part of the conclusion, i.e., : T. later during execution. If the language is described formally, we can at- ² Trapped errors are errors that force the com- tempt to prove the type soundness theorem [15]. putation to stop immediately; for example di- If the theorem holds, the type system is said to be vision by zero. The error can then be handled sound and the language type safe or or just safe. The Modelica Association 304 Modelica 2006, September 4th – 5th Types in the Modelica Language The concept of type safety can be illustrated by Language Type Safe Checking Robin Milner's famous statement "Well-typed pro- Standard ML yes static grams cannot go wrong"[9]. Modern type sound- Java yes static ness proofs are based on Wright and Felleisen's Common LISP yes dynamic approach where type systems are proven correct Modelica yes static1 together with the language's operational seman- Pascal almost static tics [15]. Using this technique, informally stated, C/C++ no static type safety hold if and only if the following two Assembler no - statements holds: Table 1: Believed type safety of selected lan- ² Preservation - If an expression e has a type T guages. and e evaluates to a value v, then v also has type T. 2.2 Subtyping Subtyping is a fundamental language concept used ² Progress - If an expression e has a type T in most modern programming languages. It means 0 then either e evaluates to a new expression e that if a type S has all the properties of another or e is a value. This means that a well typed type T, then S can be safely used in all contexts program never gets "stuck", i.e., it cannot go where type T is expected. This view of subtyp- into a unde¯ned state where no further eval- ing is often called the principle of safe substitution uations are possible.
Load more

Recommended publications
  • Applying Reinforcement Learning to Modelica Models
    ModelicaGym: Applying Reinforcement Learning to Modelica Models Oleh Lukianykhin∗ Tetiana Bogodorova [email protected] [email protected] The Machine Learning Lab, Ukrainian Catholic University Lviv, Ukraine Figure 1: A high-level overview of a considered pipeline and place of the presented toolbox in it. ABSTRACT CCS CONCEPTS This paper presents ModelicaGym toolbox that was developed • Theory of computation → Reinforcement learning; • Soft- to employ Reinforcement Learning (RL) for solving optimization ware and its engineering → Integration frameworks; System and control tasks in Modelica models. The developed tool allows modeling languages; • Computing methodologies → Model de- connecting models using Functional Mock-up Interface (FMI) to velopment and analysis. OpenAI Gym toolkit in order to exploit Modelica equation-based modeling and co-simulation together with RL algorithms as a func- KEYWORDS tionality of the tools correspondingly. Thus, ModelicaGym facilit- Cart Pole, FMI, JModelica.org, Modelica, model integration, Open ates fast and convenient development of RL algorithms and their AI Gym, OpenModelica, Python, reinforcement learning comparison when solving optimal control problem for Modelica dynamic models. Inheritance structure of ModelicaGym toolbox’s ACM Reference Format: Oleh Lukianykhin and Tetiana Bogodorova. 2019. ModelicaGym: Applying classes and the implemented methods are discussed in details. The Reinforcement Learning to Modelica Models. In EOOLT 2019: 9th Interna- toolbox functionality validation is performed on Cart-Pole balan- tional Workshop on Equation-Based Object-Oriented Modeling Languages and arXiv:1909.08604v1 [cs.SE] 18 Sep 2019 cing problem. This includes physical system model description and Tools, November 04–05, 2019, Berlin, DE. ACM, New York, NY, USA, 10 pages. its integration using the toolbox, experiments on selection and in- https://doi.org/10.1145/nnnnnnn.nnnnnnn fluence of the model parameters (i.e.
    [Show full text]
  • Optimation Optimizing Process Control with Dymola
    DS PLM SUCCESS STORY Optimation Optimizing process control with Dymola Overview Challenge Optimizing manufacturing processes define the strategies to run the mill or the Optimation needed to provide its Sweden’s Optimation helps companies to power plant at an optimum level and use customers with solutions that define optimize their manufacturing processes via simulation to test those strategies before they the optimal process control strategy for their production processes its expertise in control technology, dynamic are implemented in the real world.” simulation, and production processes. Solution Optimized process control can contribute to With Dymola, Optimation produces simulation Optimation uses Dymola to energy savings, better product quality, and results that mimic reality enabling its dynamically simulate the way a increased output. On the contrary, incorrectly customers to implement the most optimum controller should function for maximum structured and insufficiently configured configuration from the beginning. “I suppose operating capacity control systems lead to production downtime, we can say that we are control architects - we idleness or inefficiencies. Customers that turn define the optimum strategy and we create a Benefits to Optimation for process control optimization roadmap so that programmers have precise Thanks to Dymola, Optimation’s customers have a precise idea of the come from a variety of disciplines that include instructions on how to program a control way a process controller should be pulp mills, power plants, mining and steel. system,” said Eriksson. programmed before proceeding with physical modifications or installations Optimum configuration with Dymola A plant is an ensemble of hydraulic, Optimation uses Dymola, Dassault Systèmes mechanical, electrical systems. This is why multi-engineering modeling and simulation Optimation adopts a broad approach when solutions based on the open Modelica asked to optimize an existing plant.
    [Show full text]
  • Typescript Language Specification
    TypeScript Language Specification Version 1.8 January, 2016 Microsoft is making this Specification available under the Open Web Foundation Final Specification Agreement Version 1.0 ("OWF 1.0") as of October 1, 2012. The OWF 1.0 is available at http://www.openwebfoundation.org/legal/the-owf-1-0-agreements/owfa-1-0. TypeScript is a trademark of Microsoft Corporation. Table of Contents 1 Introduction ................................................................................................................................................................................... 1 1.1 Ambient Declarations ..................................................................................................................................................... 3 1.2 Function Types .................................................................................................................................................................. 3 1.3 Object Types ...................................................................................................................................................................... 4 1.4 Structural Subtyping ....................................................................................................................................................... 6 1.5 Contextual Typing ............................................................................................................................................................ 7 1.6 Classes .................................................................................................................................................................................
    [Show full text]
  • Dassault Systèmes Products Lines Releases Support Life Cycle Dates for Licensed Program
    Dassault Systèmes Products Lines Releases Support Life Cycle Dates For licensed program © Dassault Systèmes | Confidential Information | 5/23/14 | ref.: 3DS_Document_2014 ref.: Information | | 5/23/14 © Dassault | Confidential Systèmes 3DS.COM Applicable as of - 9/13/2019 Dassault Systèmes - Customer Support Table of contents 1. 3DEXPERIENCE ........................................................................................................... 4 2. 3DEXCITE ..................................................................................................................... 5 3. BIOVIA ........................................................................................................................... 6 4. CATIA Composer ........................................................................................................... 8 5. CATIA V4 ....................................................................................................................... 9 6. CATIA AITAC ............................................................................................................... 10 7. DELMIA APRISO ......................................................................................................... 11 8. DELMIA ORTEMS ....................................................................................................... 12 9. DYMOLA...................................................................................................................... 13 10. ELECTRE & ELECTRE Connectors for V5 .................................................................
    [Show full text]
  • Typescript-Handbook.Pdf
    This copy of the TypeScript handbook was created on Monday, September 27, 2021 against commit 519269 with TypeScript 4.4. Table of Contents The TypeScript Handbook Your first step to learn TypeScript The Basics Step one in learning TypeScript: The basic types. Everyday Types The language primitives. Understand how TypeScript uses JavaScript knowledge Narrowing to reduce the amount of type syntax in your projects. More on Functions Learn about how Functions work in TypeScript. How TypeScript describes the shapes of JavaScript Object Types objects. An overview of the ways in which you can create more Creating Types from Types types from existing types. Generics Types which take parameters Keyof Type Operator Using the keyof operator in type contexts. Typeof Type Operator Using the typeof operator in type contexts. Indexed Access Types Using Type['a'] syntax to access a subset of a type. Create types which act like if statements in the type Conditional Types system. Mapped Types Generating types by re-using an existing type. Generating mapping types which change properties via Template Literal Types template literal strings. Classes How classes work in TypeScript How JavaScript handles communicating across file Modules boundaries. The TypeScript Handbook About this Handbook Over 20 years after its introduction to the programming community, JavaScript is now one of the most widespread cross-platform languages ever created. Starting as a small scripting language for adding trivial interactivity to webpages, JavaScript has grown to be a language of choice for both frontend and backend applications of every size. While the size, scope, and complexity of programs written in JavaScript has grown exponentially, the ability of the JavaScript language to express the relationships between different units of code has not.
    [Show full text]
  • Reusing Static Analysis Across Di Erent Domain-Specific Languages
    Reusing Static Analysis across Dierent Domain-Specific Languages using Reference Attribute Grammars Johannes Meya, Thomas Kühnb, René Schönea, and Uwe Aßmanna a Technische Universität Dresden, Germany b Karlsruhe Institute of Technology, Germany Abstract Context: Domain-specific languages (DSLs) enable domain experts to specify tasks and problems themselves, while enabling static analysis to elucidate issues in the modelled domain early. Although language work- benches have simplified the design of DSLs and extensions to general purpose languages, static analyses must still be implemented manually. Inquiry: Moreover, static analyses, e.g., complexity metrics, dependency analysis, and declaration-use analy- sis, are usually domain-dependent and cannot be easily reused. Therefore, transferring existing static analyses to another DSL incurs a huge implementation overhead. However, this overhead is not always intrinsically necessary: in many cases, while the concepts of the DSL on which a static analysis is performed are domain- specific, the underlying algorithm employed in the analysis is actually domain-independent and thus can be reused in principle, depending on how it is specified. While current approaches either implement static anal- yses internally or with an external Visitor, the implementation is tied to the language’s grammar and cannot be reused easily. Thus far, a commonly used approach that achieves reusable static analysis relies on the trans- formation into an intermediate representation upon which the analysis is performed. This, however, entails a considerable additional implementation effort. Approach: To remedy this, it has been proposed to map the necessary domain-specific concepts to the algo- rithm’s domain-independent data structures, yet without a practical implementation and the demonstration of reuse.
    [Show full text]
  • Comparative Studies of Programming Languages; Course Lecture Notes
    Comparative Studies of Programming Languages, COMP6411 Lecture Notes, Revision 1.9 Joey Paquet Serguei A. Mokhov (Eds.) August 5, 2010 arXiv:1007.2123v6 [cs.PL] 4 Aug 2010 2 Preface Lecture notes for the Comparative Studies of Programming Languages course, COMP6411, taught at the Department of Computer Science and Software Engineering, Faculty of Engineering and Computer Science, Concordia University, Montreal, QC, Canada. These notes include a compiled book of primarily related articles from the Wikipedia, the Free Encyclopedia [24], as well as Comparative Programming Languages book [7] and other resources, including our own. The original notes were compiled by Dr. Paquet [14] 3 4 Contents 1 Brief History and Genealogy of Programming Languages 7 1.1 Introduction . 7 1.1.1 Subreferences . 7 1.2 History . 7 1.2.1 Pre-computer era . 7 1.2.2 Subreferences . 8 1.2.3 Early computer era . 8 1.2.4 Subreferences . 8 1.2.5 Modern/Structured programming languages . 9 1.3 References . 19 2 Programming Paradigms 21 2.1 Introduction . 21 2.2 History . 21 2.2.1 Low-level: binary, assembly . 21 2.2.2 Procedural programming . 22 2.2.3 Object-oriented programming . 23 2.2.4 Declarative programming . 27 3 Program Evaluation 33 3.1 Program analysis and translation phases . 33 3.1.1 Front end . 33 3.1.2 Back end . 34 3.2 Compilation vs. interpretation . 34 3.2.1 Compilation . 34 3.2.2 Interpretation . 36 3.2.3 Subreferences . 37 3.3 Type System . 38 3.3.1 Type checking . 38 3.4 Memory management .
    [Show full text]
  • Cross-Platform Language Design
    Cross-Platform Language Design THIS IS A TEMPORARY TITLE PAGE It will be replaced for the final print by a version provided by the service academique. Thèse n. 1234 2011 présentée le 11 Juin 2018 à la Faculté Informatique et Communications Laboratoire de Méthodes de Programmation 1 programme doctoral en Informatique et Communications École Polytechnique Fédérale de Lausanne pour l’obtention du grade de Docteur ès Sciences par Sébastien Doeraene acceptée sur proposition du jury: Prof James Larus, président du jury Prof Martin Odersky, directeur de thèse Prof Edouard Bugnion, rapporteur Dr Andreas Rossberg, rapporteur Prof Peter Van Roy, rapporteur Lausanne, EPFL, 2018 It is better to repent a sin than regret the loss of a pleasure. — Oscar Wilde Acknowledgments Although there is only one name written in a large font on the front page, there are many people without which this thesis would never have happened, or would not have been quite the same. Five years is a long time, during which I had the privilege to work, discuss, sing, learn and have fun with many people. I am afraid to make a list, for I am sure I will forget some. Nevertheless, I will try my best. First, I would like to thank my advisor, Martin Odersky, for giving me the opportunity to fulfill a dream, that of being part of the design and development team of my favorite programming language. Many thanks for letting me explore the design of Scala.js in my own way, while at the same time always being there when I needed him.
    [Show full text]
  • Behavioral Types in Programming Languages
    Behavioral Types in Programming Languages Behavioral Types in Programming Languages iv Davide Ancona, DIBRIS, Università di Genova, Italy Viviana Bono, Dipartimento di Informatica, Università di Torino, Italy Mario Bravetti, Università di Bologna, Italy / INRIA, France Joana Campos, LaSIGE, Faculdade de Ciências, Universidade de Lisboa, Portugal Giuseppe Castagna, CNRS, IRIF, Univ Paris Diderot, Sorbonne Paris Cité, Paris, France Pierre-Malo Deniélou, Royal Holloway, University of London, UK Simon J. Gay, School of Computing Science, University of Glasgow, UK Nils Gesbert, Université Grenoble Alpes, France Elena Giachino, Università di Bologna, Italy / INRIA, France Raymond Hu, Department of Computing, Imperial College London, UK Einar Broch Johnsen, Institutt for informatikk, Universitetet i Oslo, Norway Francisco Martins, LaSIGE, Faculdade de Ciências, Universidade de Lisboa, Portugal Viviana Mascardi, DIBRIS, Università di Genova, Italy Fabrizio Montesi, University of Southern Denmark Rumyana Neykova, Department of Computing, Imperial College London, UK Nicholas Ng, Department of Computing, Imperial College London, UK Luca Padovani, Dipartimento di Informatica, Università di Torino, Italy Vasco T. Vasconcelos, LaSIGE, Faculdade de Ciências, Universidade de Lisboa, Portugal Nobuko Yoshida, Department of Computing, Imperial College London, UK Boston — Delft Foundations and Trends R in Programming Languages Published, sold and distributed by: now Publishers Inc. PO Box 1024 Hanover, MA 02339 United States Tel. +1-781-985-4510 www.nowpublishers.com [email protected] Outside North America: now Publishers Inc. PO Box 179 2600 AD Delft The Netherlands Tel. +31-6-51115274 The preferred citation for this publication is D. Ancona et al.. Behavioral Types in Programming Languages. Foundations and Trends R in Programming Languages, vol. 3, no.
    [Show full text]
  • Context-Aware Programming Languages
    UCAM-CL-TR-906 Technical Report ISSN 1476-2986 Number 906 Computer Laboratory Context-aware programming languages Tomas Petricek March 2017 15 JJ Thomson Avenue Cambridge CB3 0FD United Kingdom phone +44 1223 763500 http://www.cl.cam.ac.uk/ c 2017 Tomas Petricek This technical report is based on a dissertation submitted March 2017 by the author for the degree of Doctor of Philosophy to the University of Cambridge, Clare Hall. Technical reports published by the University of Cambridge Computer Laboratory are freely available via the Internet: http://www.cl.cam.ac.uk/techreports/ ISSN 1476-2986 ABSTRACT The development of programming languages needs to reflect important changes in the way programs execute. In recent years, this has included the development of parallel programming models (in reaction to the multi- core revolution) or improvements in data access technologies. This thesis is a response to another such revolution – the diversification of devices and systems where programs run. The key point made by this thesis is the realization that an execution en- vironment or a context is fundamental for writing modern applications and that programming languages should provide abstractions for programming with context and verifying how it is accessed. We identify a number of program properties that were not connected before, but model some notion of context. Our examples include tracking different execution platforms (and their versions) in cross-platform devel- opment, resources available in different execution environments (e. g. GPS sensor on a phone and database on the server), but also more traditional notions such as variable usage (e. g.
    [Show full text]
  • Introduction to Dymola
    DYMOLA AND MODELICA Course overview DAY 1 Dymola and Modelica I • Introduction Dymola, Modelica, Modelon • Lecture 1 Overview of Dymola and Physical modeling . Workshop 1 Workflow of modeling physical systems in Dymola • Lecture 2 Simulation and post-processing with Dymola . Workshop 2 Simulating and analyzing a physical system • Lecture 3 Configure system models . Workshop 3 Creating a reconfigurable system DAY 2 Dymola and Modelica I • Lecture 4 Modelica I – Writing Modelica models . Workshop 4a Cauer low pass filter using Electric Library . Workshop 4b A moving coil using Magnetic, Electric and Translational mechanics libraries . Workshop 4c Temperature control using Heat transfer Library • Lecture 5 Understanding equation-based modeling . Workshop 5 Defining boundary conditions • Lecture 6 Trouble shooting and common pitfalls . Workshop 6 Common pitfalls DAY 3 Dymola and Modelica II • Lecture 7 Modelica II – Advanced features . Workshop 7 Implementing a solar collector • Lecture 8 Working with the Modelica Standard Library . Workshop 8a Lamp logic using StateGraph II . Workshop 8b Suspension linkage using MultiBody mechanics • Lecture 9 Hybrid modeling . Workshop 9a Hybrid examples . Workshop 9b Hammer impact model . Workshop 9c Designing a thermostat valve DAY 4 Dymola and Modelica II • Lecture 10 Efficient and reconfigurable modeling . Workshop 10 Creating a system architecture based on templates and interfaces • Lecture 11 Model variants and data management . Workshop 11 Creating a data architecture and adaptive parameter interfaces • Lecture 12 FMI technology . Workshop 12a Import and Export FMUs in Dymola . Workshop 12b FMI with Excel . Workshop 12c FMI with Simulink DAY 5 Dymola and Modelica II • Lecture 13 Workflow automation and scripting . Workshop 13 Automated sensitivity analysis • Lecture 14 Dymola code with other tools .
    [Show full text]
  • 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]